// $ANTLR 3.4 C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g 2012-10-10 15:31:19

package PL.prac4;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

@SuppressWarnings({"all", "warnings", "unchecked"})
public class Analex extends Lexer {
    public static final int EOF=-1;
    public static final int AMPERSAND=4;
    public static final int BLANCO=5;
    public static final int CADENA=6;
    public static final int COMA=7;
    public static final int COMENTARIO=8;
    public static final int COMPARADOR=9;
    public static final int DIGITO=10;
    public static final int ESPACIO=11;
    public static final int IDENT=12;
    public static final int IF=13;
    public static final int IGUAL=14;
    public static final int INT=15;
    public static final int LETRA=16;
    public static final int LINEA_COMENTARIO=17;
    public static final int LIT_ENTERO=18;
    public static final int LIT_REAL=19;
    public static final int LLAVES=20;
    public static final int NUEVA_LINEA=21;
    public static final int NUMERO=22;
    public static final int OPERADOR=23;
    public static final int PARENTESIS=24;
    public static final int SEPARADOR=25;
    public static final int VOID=26;
    public static final int WHILE=27;

    public class MiToken extends CommonToken {
      private String nuevoAtributo;
      
      public MiToken (CharStream input, int type, int channel, int start, int stop) {
        super(input, type, channel, start, stop);
        nuevoAtributo = getSourceName();
      }
      public void setNuevoAtributo(String s) {
      nuevoAtributo=s;
      }
      public String getNuevoAtributo() {
      return nuevoAtributo;
      }
      public String toString() {
      String aux;
      aux = "Linea " + getLine() + ", "+ getCharPositionInLine()+ ": encontrado "+ getText() + ", Regla: " + getType() + ". Fichero: " + nuevoAtributo;
      return aux;
      }
    }
    // override standard token emission
    public Token emit() {
        MiToken t = new MiToken(input, state.type, state.channel,
                        state.tokenStartCharIndex, getCharIndex()-1);
        t.setLine(state.tokenStartLine);
        t.setText(state.text);
        t.setCharPositionInLine(state.tokenStartCharPositionInLine);
        emit(t);
        return t;
    }



    // delegates
    // delegators
    public Lexer[] getDelegates() {
        return new Lexer[] {};
    }

    public Analex() {} 
    public Analex(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public Analex(CharStream input, RecognizerSharedState state) {
        super(input,state);
    }
    public String getGrammarFileName() { return "C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g"; }

    // $ANTLR start "INT"
    public final void mINT() throws RecognitionException {
        try {
            int _type = INT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:54:5: ( 'i' | 'I' 'n' | 'N' 't' | 'T' )
            int alt1=4;
            switch ( input.LA(1) ) {
            case 'i':
                {
                alt1=1;
                }
                break;
            case 'I':
                {
                alt1=2;
                }
                break;
            case 'N':
                {
                alt1=3;
                }
                break;
            case 'T':
                {
                alt1=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                throw nvae;

            }

            switch (alt1) {
                case 1 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:54:7: 'i'
                    {
                    match('i'); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:54:11: 'I' 'n'
                    {
                    match('I'); if (state.failed) return ;

                    match('n'); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:54:19: 'N' 't'
                    {
                    match('N'); if (state.failed) return ;

                    match('t'); if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:54:27: 'T'
                    {
                    match('T'); if (state.failed) return ;

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "INT"

    // $ANTLR start "VOID"
    public final void mVOID() throws RecognitionException {
        try {
            int _type = VOID;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:55:6: ( 'v' | 'V' 'o' | 'O' 'i' | 'I' 'd' | 'D' )
            int alt2=5;
            switch ( input.LA(1) ) {
            case 'v':
                {
                alt2=1;
                }
                break;
            case 'V':
                {
                alt2=2;
                }
                break;
            case 'O':
                {
                alt2=3;
                }
                break;
            case 'I':
                {
                alt2=4;
                }
                break;
            case 'D':
                {
                alt2=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;

            }

            switch (alt2) {
                case 1 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:55:8: 'v'
                    {
                    match('v'); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:55:12: 'V' 'o'
                    {
                    match('V'); if (state.failed) return ;

                    match('o'); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:55:20: 'O' 'i'
                    {
                    match('O'); if (state.failed) return ;

                    match('i'); if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:55:28: 'I' 'd'
                    {
                    match('I'); if (state.failed) return ;

                    match('d'); if (state.failed) return ;

                    }
                    break;
                case 5 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:55:36: 'D'
                    {
                    match('D'); if (state.failed) return ;

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "VOID"

    // $ANTLR start "IF"
    public final void mIF() throws RecognitionException {
        try {
            int _type = IF;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:57:4: ( 'i' | 'I' 'f' | 'F' )
            int alt3=3;
            switch ( input.LA(1) ) {
            case 'i':
                {
                alt3=1;
                }
                break;
            case 'I':
                {
                alt3=2;
                }
                break;
            case 'F':
                {
                alt3=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;

            }

            switch (alt3) {
                case 1 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:57:6: 'i'
                    {
                    match('i'); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:57:11: 'I' 'f'
                    {
                    match('I'); if (state.failed) return ;

                    match('f'); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:57:19: 'F'
                    {
                    match('F'); if (state.failed) return ;

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "IF"

    // $ANTLR start "WHILE"
    public final void mWHILE() throws RecognitionException {
        try {
            int _type = WHILE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:58:7: ( 'w' | 'W' 'i' | 'I' 'l' | 'L' 'e' | 'E' )
            int alt4=5;
            switch ( input.LA(1) ) {
            case 'w':
                {
                alt4=1;
                }
                break;
            case 'W':
                {
                alt4=2;
                }
                break;
            case 'I':
                {
                alt4=3;
                }
                break;
            case 'L':
                {
                alt4=4;
                }
                break;
            case 'E':
                {
                alt4=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;

            }

            switch (alt4) {
                case 1 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:58:9: 'w'
                    {
                    match('w'); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:58:13: 'W' 'i'
                    {
                    match('W'); if (state.failed) return ;

                    match('i'); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:58:21: 'I' 'l'
                    {
                    match('I'); if (state.failed) return ;

                    match('l'); if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:58:30: 'L' 'e'
                    {
                    match('L'); if (state.failed) return ;

                    match('e'); if (state.failed) return ;

                    }
                    break;
                case 5 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:58:38: 'E'
                    {
                    match('E'); if (state.failed) return ;

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "WHILE"

    // $ANTLR start "NUEVA_LINEA"
    public final void mNUEVA_LINEA() throws RecognitionException {
        try {
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:60:22: ( ( '\\r\\n' | '\\n' ) )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:60:24: ( '\\r\\n' | '\\n' )
            {
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:60:24: ( '\\r\\n' | '\\n' )
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0=='\r') ) {
                alt5=1;
            }
            else if ( (LA5_0=='\n') ) {
                alt5=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;

            }
            switch (alt5) {
                case 1 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:60:25: '\\r\\n'
                    {
                    match("\r\n"); if (state.failed) return ;



                    }
                    break;
                case 2 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:60:32: '\\n'
                    {
                    match('\n'); if (state.failed) return ;

                    }
                    break;

            }


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "NUEVA_LINEA"

    // $ANTLR start "ESPACIO"
    public final void mESPACIO() throws RecognitionException {
        try {
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:61:17: ( ( ' ' ) )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:61:19: ( ' ' )
            {
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:61:19: ( ' ' )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:61:20: ' '
            {
            match(' '); if (state.failed) return ;

            }


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ESPACIO"

    // $ANTLR start "BLANCO"
    public final void mBLANCO() throws RecognitionException {
        try {
            int _type = BLANCO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:62:7: ( ( ESPACIO | '\\t' | '\\r' | NUEVA_LINEA ) )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:62:9: ( ESPACIO | '\\t' | '\\r' | NUEVA_LINEA )
            {
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:62:9: ( ESPACIO | '\\t' | '\\r' | NUEVA_LINEA )
            int alt6=4;
            switch ( input.LA(1) ) {
            case ' ':
                {
                alt6=1;
                }
                break;
            case '\t':
                {
                alt6=2;
                }
                break;
            case '\r':
                {
                int LA6_3 = input.LA(2);

                if ( (LA6_3=='\n') ) {
                    alt6=4;
                }
                else {
                    alt6=3;
                }
                }
                break;
            case '\n':
                {
                alt6=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;

            }

            switch (alt6) {
                case 1 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:62:10: ESPACIO
                    {
                    mESPACIO(); if (state.failed) return ;


                    }
                    break;
                case 2 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:62:18: '\\t'
                    {
                    match('\t'); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:62:23: '\\r'
                    {
                    match('\r'); if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:62:28: NUEVA_LINEA
                    {
                    mNUEVA_LINEA(); if (state.failed) return ;


                    }
                    break;

            }


            if ( state.backtracking==0 ) {_channel = HIDDEN;}

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "BLANCO"

    // $ANTLR start "DIGITO"
    public final void mDIGITO() throws RecognitionException {
        try {
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:64:17: ( '0' .. '9' )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:
            {
            if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
                input.consume();
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "DIGITO"

    // $ANTLR start "NUMERO"
    public final void mNUMERO() throws RecognitionException {
        try {
            int _type = NUMERO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:65:8: ( ( ( DIGITO )+ '.' )=> ( DIGITO )+ '.' ( DIGITO )* | ( DIGITO )+ )
            int alt10=2;
            alt10 = dfa10.predict(input);
            switch (alt10) {
                case 1 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:65:10: ( ( DIGITO )+ '.' )=> ( DIGITO )+ '.' ( DIGITO )*
                    {
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:65:29: ( DIGITO )+
                    int cnt7=0;
                    loop7:
                    do {
                        int alt7=2;
                        int LA7_0 = input.LA(1);

                        if ( ((LA7_0 >= '0' && LA7_0 <= '9')) ) {
                            alt7=1;
                        }


                        switch (alt7) {
                    	case 1 :
                    	    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:
                    	    {
                    	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
                    	        input.consume();
                    	        state.failed=false;
                    	    }
                    	    else {
                    	        if (state.backtracking>0) {state.failed=true; return ;}
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    if ( cnt7 >= 1 ) break loop7;
                    	    if (state.backtracking>0) {state.failed=true; return ;}
                                EarlyExitException eee =
                                    new EarlyExitException(7, input);
                                throw eee;
                        }
                        cnt7++;
                    } while (true);


                    match('.'); if (state.failed) return ;

                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:65:43: ( DIGITO )*
                    loop8:
                    do {
                        int alt8=2;
                        int LA8_0 = input.LA(1);

                        if ( ((LA8_0 >= '0' && LA8_0 <= '9')) ) {
                            alt8=1;
                        }


                        switch (alt8) {
                    	case 1 :
                    	    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:
                    	    {
                    	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
                    	        input.consume();
                    	        state.failed=false;
                    	    }
                    	    else {
                    	        if (state.backtracking>0) {state.failed=true; return ;}
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    break loop8;
                        }
                    } while (true);


                    if ( state.backtracking==0 ) { _type = LIT_REAL; }

                    }
                    break;
                case 2 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:65:75: ( DIGITO )+
                    {
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:65:75: ( DIGITO )+
                    int cnt9=0;
                    loop9:
                    do {
                        int alt9=2;
                        int LA9_0 = input.LA(1);

                        if ( ((LA9_0 >= '0' && LA9_0 <= '9')) ) {
                            alt9=1;
                        }


                        switch (alt9) {
                    	case 1 :
                    	    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:
                    	    {
                    	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
                    	        input.consume();
                    	        state.failed=false;
                    	    }
                    	    else {
                    	        if (state.backtracking>0) {state.failed=true; return ;}
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    if ( cnt9 >= 1 ) break loop9;
                    	    if (state.backtracking>0) {state.failed=true; return ;}
                                EarlyExitException eee =
                                    new EarlyExitException(9, input);
                                throw eee;
                        }
                        cnt9++;
                    } while (true);


                    if ( state.backtracking==0 ) { _type = LIT_ENTERO; }

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "NUMERO"

    // $ANTLR start "LETRA"
    public final void mLETRA() throws RecognitionException {
        try {
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:67:15: ( ( 'a' .. 'z' ) | ( 'A' .. 'Z' ) )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:
            {
            if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z')||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
                input.consume();
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LETRA"

    // $ANTLR start "IDENT"
    public final void mIDENT() throws RecognitionException {
        try {
            int _type = IDENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:68:8: ( LETRA ( DIGITO | LETRA )* )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:68:10: LETRA ( DIGITO | LETRA )*
            {
            mLETRA(); if (state.failed) return ;


            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:68:16: ( DIGITO | LETRA )*
            loop11:
            do {
                int alt11=2;
                int LA11_0 = input.LA(1);

                if ( ((LA11_0 >= '0' && LA11_0 <= '9')||(LA11_0 >= 'A' && LA11_0 <= 'Z')||(LA11_0 >= 'a' && LA11_0 <= 'z')) ) {
                    alt11=1;
                }


                switch (alt11) {
            	case 1 :
            	    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:
            	    {
            	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
            	        input.consume();
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop11;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "IDENT"

    // $ANTLR start "OPERADOR"
    public final void mOPERADOR() throws RecognitionException {
        try {
            int _type = OPERADOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:70:11: ( '+' | '-' | '/' | '*' | '++' | '--' )
            int alt12=6;
            switch ( input.LA(1) ) {
            case '+':
                {
                int LA12_1 = input.LA(2);

                if ( (LA12_1=='+') ) {
                    alt12=5;
                }
                else {
                    alt12=1;
                }
                }
                break;
            case '-':
                {
                int LA12_2 = input.LA(2);

                if ( (LA12_2=='-') ) {
                    alt12=6;
                }
                else {
                    alt12=2;
                }
                }
                break;
            case '/':
                {
                alt12=3;
                }
                break;
            case '*':
                {
                alt12=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;

            }

            switch (alt12) {
                case 1 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:70:13: '+'
                    {
                    match('+'); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:70:19: '-'
                    {
                    match('-'); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:70:25: '/'
                    {
                    match('/'); if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:70:31: '*'
                    {
                    match('*'); if (state.failed) return ;

                    }
                    break;
                case 5 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:70:37: '++'
                    {
                    match("++"); if (state.failed) return ;



                    }
                    break;
                case 6 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:70:44: '--'
                    {
                    match("--"); if (state.failed) return ;



                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "OPERADOR"

    // $ANTLR start "PARENTESIS"
    public final void mPARENTESIS() throws RecognitionException {
        try {
            int _type = PARENTESIS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:71:13: ( '(' | ')' )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:
            {
            if ( (input.LA(1) >= '(' && input.LA(1) <= ')') ) {
                input.consume();
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "PARENTESIS"

    // $ANTLR start "LLAVES"
    public final void mLLAVES() throws RecognitionException {
        try {
            int _type = LLAVES;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:72:9: ( '{' | '}' )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:
            {
            if ( input.LA(1)=='{'||input.LA(1)=='}' ) {
                input.consume();
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LLAVES"

    // $ANTLR start "COMA"
    public final void mCOMA() throws RecognitionException {
        try {
            int _type = COMA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:73:7: ( ',' )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:73:9: ','
            {
            match(','); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMA"

    // $ANTLR start "AMPERSAND"
    public final void mAMPERSAND() throws RecognitionException {
        try {
            int _type = AMPERSAND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:74:12: ( '&' )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:74:14: '&'
            {
            match('&'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "AMPERSAND"

    // $ANTLR start "COMPARADOR"
    public final void mCOMPARADOR() throws RecognitionException {
        try {
            int _type = COMPARADOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:75:13: ( '<' | '>' | '<=' | '>=' )
            int alt13=4;
            int LA13_0 = input.LA(1);

            if ( (LA13_0=='<') ) {
                int LA13_1 = input.LA(2);

                if ( (LA13_1=='=') ) {
                    alt13=3;
                }
                else {
                    alt13=1;
                }
            }
            else if ( (LA13_0=='>') ) {
                int LA13_2 = input.LA(2);

                if ( (LA13_2=='=') ) {
                    alt13=4;
                }
                else {
                    alt13=2;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 13, 0, input);

                throw nvae;

            }
            switch (alt13) {
                case 1 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:75:15: '<'
                    {
                    match('<'); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:75:21: '>'
                    {
                    match('>'); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:75:27: '<='
                    {
                    match("<="); if (state.failed) return ;



                    }
                    break;
                case 4 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:75:34: '>='
                    {
                    match(">="); if (state.failed) return ;



                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMPARADOR"

    // $ANTLR start "SEPARADOR"
    public final void mSEPARADOR() throws RecognitionException {
        try {
            int _type = SEPARADOR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:76:12: ( ';' )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:76:14: ';'
            {
            match(';'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "SEPARADOR"

    // $ANTLR start "IGUAL"
    public final void mIGUAL() throws RecognitionException {
        try {
            int _type = IGUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:77:8: ( '=' )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:77:10: '='
            {
            match('='); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "IGUAL"

    // $ANTLR start "CADENA"
    public final void mCADENA() throws RecognitionException {
        try {
            int _type = CADENA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:78:9: ( '\"' ( LETRA | DIGITO | '\\\\' | '%' | BLANCO )* '\"' )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:78:11: '\"' ( LETRA | DIGITO | '\\\\' | '%' | BLANCO )* '\"'
            {
            match('\"'); if (state.failed) return ;

            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:78:15: ( LETRA | DIGITO | '\\\\' | '%' | BLANCO )*
            loop14:
            do {
                int alt14=6;
                switch ( input.LA(1) ) {
                case 'A':
                case 'B':
                case 'C':
                case 'D':
                case 'E':
                case 'F':
                case 'G':
                case 'H':
                case 'I':
                case 'J':
                case 'K':
                case 'L':
                case 'M':
                case 'N':
                case 'O':
                case 'P':
                case 'Q':
                case 'R':
                case 'S':
                case 'T':
                case 'U':
                case 'V':
                case 'W':
                case 'X':
                case 'Y':
                case 'Z':
                case 'a':
                case 'b':
                case 'c':
                case 'd':
                case 'e':
                case 'f':
                case 'g':
                case 'h':
                case 'i':
                case 'j':
                case 'k':
                case 'l':
                case 'm':
                case 'n':
                case 'o':
                case 'p':
                case 'q':
                case 'r':
                case 's':
                case 't':
                case 'u':
                case 'v':
                case 'w':
                case 'x':
                case 'y':
                case 'z':
                    {
                    alt14=1;
                    }
                    break;
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                    {
                    alt14=2;
                    }
                    break;
                case '\\':
                    {
                    alt14=3;
                    }
                    break;
                case '%':
                    {
                    alt14=4;
                    }
                    break;
                case '\t':
                case '\n':
                case '\r':
                case ' ':
                    {
                    alt14=5;
                    }
                    break;

                }

                switch (alt14) {
            	case 1 :
            	    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:78:16: LETRA
            	    {
            	    mLETRA(); if (state.failed) return ;


            	    }
            	    break;
            	case 2 :
            	    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:78:22: DIGITO
            	    {
            	    mDIGITO(); if (state.failed) return ;


            	    }
            	    break;
            	case 3 :
            	    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:78:29: '\\\\'
            	    {
            	    match('\\'); if (state.failed) return ;

            	    }
            	    break;
            	case 4 :
            	    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:78:34: '%'
            	    {
            	    match('%'); if (state.failed) return ;

            	    }
            	    break;
            	case 5 :
            	    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:78:38: BLANCO
            	    {
            	    mBLANCO(); if (state.failed) return ;


            	    }
            	    break;

            	default :
            	    break loop14;
                }
            } while (true);


            match('\"'); if (state.failed) return ;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CADENA"

    // $ANTLR start "COMENTARIO"
    public final void mCOMENTARIO() throws RecognitionException {
        try {
            int _type = COMENTARIO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:80:11: ( '/*' ( '*' ~ ( '/' ) |~ ( '*' ) )* ( '*' )? '*/' )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:80:13: '/*' ( '*' ~ ( '/' ) |~ ( '*' ) )* ( '*' )? '*/'
            {
            match("/*"); if (state.failed) return ;



            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:80:18: ( '*' ~ ( '/' ) |~ ( '*' ) )*
            loop15:
            do {
                int alt15=3;
                int LA15_0 = input.LA(1);

                if ( (LA15_0=='*') ) {
                    int LA15_1 = input.LA(2);

                    if ( (LA15_1=='*') ) {
                        int LA15_4 = input.LA(3);

                        if ( (LA15_4=='/') ) {
                            int LA15_6 = input.LA(4);

                            if ( ((LA15_6 >= '\u0000' && LA15_6 <= '\uFFFF')) ) {
                                alt15=1;
                            }


                        }
                        else if ( ((LA15_4 >= '\u0000' && LA15_4 <= '.')||(LA15_4 >= '0' && LA15_4 <= '\uFFFF')) ) {
                            alt15=1;
                        }


                    }
                    else if ( ((LA15_1 >= '\u0000' && LA15_1 <= ')')||(LA15_1 >= '+' && LA15_1 <= '.')||(LA15_1 >= '0' && LA15_1 <= '\uFFFF')) ) {
                        alt15=1;
                    }


                }
                else if ( ((LA15_0 >= '\u0000' && LA15_0 <= ')')||(LA15_0 >= '+' && LA15_0 <= '\uFFFF')) ) {
                    alt15=2;
                }


                switch (alt15) {
            	case 1 :
            	    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:80:19: '*' ~ ( '/' )
            	    {
            	    match('*'); if (state.failed) return ;

            	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '.')||(input.LA(1) >= '0' && input.LA(1) <= '\uFFFF') ) {
            	        input.consume();
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;
            	case 2 :
            	    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:80:31: ~ ( '*' )
            	    {
            	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= ')')||(input.LA(1) >= '+' && input.LA(1) <= '\uFFFF') ) {
            	        input.consume();
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop15;
                }
            } while (true);


            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:80:40: ( '*' )?
            int alt16=2;
            int LA16_0 = input.LA(1);

            if ( (LA16_0=='*') ) {
                int LA16_1 = input.LA(2);

                if ( (LA16_1=='*') ) {
                    alt16=1;
                }
            }
            switch (alt16) {
                case 1 :
                    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:80:40: '*'
                    {
                    match('*'); if (state.failed) return ;

                    }
                    break;

            }


            match("*/"); if (state.failed) return ;



            if ( state.backtracking==0 ) {_channel = HIDDEN;}

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMENTARIO"

    // $ANTLR start "LINEA_COMENTARIO"
    public final void mLINEA_COMENTARIO() throws RecognitionException {
        try {
            int _type = LINEA_COMENTARIO;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:82:17: ( '//' ( . )* NUEVA_LINEA )
            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:82:19: '//' ( . )* NUEVA_LINEA
            {
            match("//"); if (state.failed) return ;



            // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:82:24: ( . )*
            loop17:
            do {
                int alt17=2;
                int LA17_0 = input.LA(1);

                if ( (LA17_0=='\r') ) {
                    int LA17_1 = input.LA(2);

                    if ( (LA17_1=='\n') ) {
                        alt17=2;
                    }
                    else if ( ((LA17_1 >= '\u0000' && LA17_1 <= '\t')||(LA17_1 >= '\u000B' && LA17_1 <= '\uFFFF')) ) {
                        alt17=1;
                    }


                }
                else if ( (LA17_0=='\n') ) {
                    alt17=2;
                }
                else if ( ((LA17_0 >= '\u0000' && LA17_0 <= '\t')||(LA17_0 >= '\u000B' && LA17_0 <= '\f')||(LA17_0 >= '\u000E' && LA17_0 <= '\uFFFF')) ) {
                    alt17=1;
                }


                switch (alt17) {
            	case 1 :
            	    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:82:25: .
            	    {
            	    matchAny(); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop17;
                }
            } while (true);


            mNUEVA_LINEA(); if (state.failed) return ;


            if ( state.backtracking==0 ) {_channel = HIDDEN;}

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LINEA_COMENTARIO"

    public void mTokens() throws RecognitionException {
        // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:8: ( INT | VOID | IF | WHILE | BLANCO | NUMERO | IDENT | OPERADOR | PARENTESIS | LLAVES | COMA | AMPERSAND | COMPARADOR | SEPARADOR | IGUAL | CADENA | COMENTARIO | LINEA_COMENTARIO )
        int alt18=18;
        switch ( input.LA(1) ) {
        case 'i':
            {
            int LA18_1 = input.LA(2);

            if ( ((LA18_1 >= '0' && LA18_1 <= '9')||(LA18_1 >= 'A' && LA18_1 <= 'Z')||(LA18_1 >= 'a' && LA18_1 <= 'z')) ) {
                alt18=7;
            }
            else {
                alt18=1;
            }
            }
            break;
        case 'I':
            {
            switch ( input.LA(2) ) {
            case 'n':
                {
                int LA18_28 = input.LA(3);

                if ( ((LA18_28 >= '0' && LA18_28 <= '9')||(LA18_28 >= 'A' && LA18_28 <= 'Z')||(LA18_28 >= 'a' && LA18_28 <= 'z')) ) {
                    alt18=7;
                }
                else {
                    alt18=1;
                }
                }
                break;
            case 'd':
                {
                int LA18_29 = input.LA(3);

                if ( ((LA18_29 >= '0' && LA18_29 <= '9')||(LA18_29 >= 'A' && LA18_29 <= 'Z')||(LA18_29 >= 'a' && LA18_29 <= 'z')) ) {
                    alt18=7;
                }
                else {
                    alt18=2;
                }
                }
                break;
            case 'f':
                {
                int LA18_30 = input.LA(3);

                if ( ((LA18_30 >= '0' && LA18_30 <= '9')||(LA18_30 >= 'A' && LA18_30 <= 'Z')||(LA18_30 >= 'a' && LA18_30 <= 'z')) ) {
                    alt18=7;
                }
                else {
                    alt18=3;
                }
                }
                break;
            case 'l':
                {
                int LA18_31 = input.LA(3);

                if ( ((LA18_31 >= '0' && LA18_31 <= '9')||(LA18_31 >= 'A' && LA18_31 <= 'Z')||(LA18_31 >= 'a' && LA18_31 <= 'z')) ) {
                    alt18=7;
                }
                else {
                    alt18=4;
                }
                }
                break;
            default:
                alt18=7;
            }

            }
            break;
        case 'N':
            {
            int LA18_3 = input.LA(2);

            if ( (LA18_3=='t') ) {
                int LA18_32 = input.LA(3);

                if ( ((LA18_32 >= '0' && LA18_32 <= '9')||(LA18_32 >= 'A' && LA18_32 <= 'Z')||(LA18_32 >= 'a' && LA18_32 <= 'z')) ) {
                    alt18=7;
                }
                else {
                    alt18=1;
                }
            }
            else {
                alt18=7;
            }
            }
            break;
        case 'T':
            {
            int LA18_4 = input.LA(2);

            if ( ((LA18_4 >= '0' && LA18_4 <= '9')||(LA18_4 >= 'A' && LA18_4 <= 'Z')||(LA18_4 >= 'a' && LA18_4 <= 'z')) ) {
                alt18=7;
            }
            else {
                alt18=1;
            }
            }
            break;
        case 'v':
            {
            int LA18_5 = input.LA(2);

            if ( ((LA18_5 >= '0' && LA18_5 <= '9')||(LA18_5 >= 'A' && LA18_5 <= 'Z')||(LA18_5 >= 'a' && LA18_5 <= 'z')) ) {
                alt18=7;
            }
            else {
                alt18=2;
            }
            }
            break;
        case 'V':
            {
            int LA18_6 = input.LA(2);

            if ( (LA18_6=='o') ) {
                int LA18_34 = input.LA(3);

                if ( ((LA18_34 >= '0' && LA18_34 <= '9')||(LA18_34 >= 'A' && LA18_34 <= 'Z')||(LA18_34 >= 'a' && LA18_34 <= 'z')) ) {
                    alt18=7;
                }
                else {
                    alt18=2;
                }
            }
            else {
                alt18=7;
            }
            }
            break;
        case 'O':
            {
            int LA18_7 = input.LA(2);

            if ( (LA18_7=='i') ) {
                int LA18_35 = input.LA(3);

                if ( ((LA18_35 >= '0' && LA18_35 <= '9')||(LA18_35 >= 'A' && LA18_35 <= 'Z')||(LA18_35 >= 'a' && LA18_35 <= 'z')) ) {
                    alt18=7;
                }
                else {
                    alt18=2;
                }
            }
            else {
                alt18=7;
            }
            }
            break;
        case 'D':
            {
            int LA18_8 = input.LA(2);

            if ( ((LA18_8 >= '0' && LA18_8 <= '9')||(LA18_8 >= 'A' && LA18_8 <= 'Z')||(LA18_8 >= 'a' && LA18_8 <= 'z')) ) {
                alt18=7;
            }
            else {
                alt18=2;
            }
            }
            break;
        case 'F':
            {
            int LA18_9 = input.LA(2);

            if ( ((LA18_9 >= '0' && LA18_9 <= '9')||(LA18_9 >= 'A' && LA18_9 <= 'Z')||(LA18_9 >= 'a' && LA18_9 <= 'z')) ) {
                alt18=7;
            }
            else {
                alt18=3;
            }
            }
            break;
        case 'w':
            {
            int LA18_10 = input.LA(2);

            if ( ((LA18_10 >= '0' && LA18_10 <= '9')||(LA18_10 >= 'A' && LA18_10 <= 'Z')||(LA18_10 >= 'a' && LA18_10 <= 'z')) ) {
                alt18=7;
            }
            else {
                alt18=4;
            }
            }
            break;
        case 'W':
            {
            int LA18_11 = input.LA(2);

            if ( (LA18_11=='i') ) {
                int LA18_38 = input.LA(3);

                if ( ((LA18_38 >= '0' && LA18_38 <= '9')||(LA18_38 >= 'A' && LA18_38 <= 'Z')||(LA18_38 >= 'a' && LA18_38 <= 'z')) ) {
                    alt18=7;
                }
                else {
                    alt18=4;
                }
            }
            else {
                alt18=7;
            }
            }
            break;
        case 'L':
            {
            int LA18_12 = input.LA(2);

            if ( (LA18_12=='e') ) {
                int LA18_39 = input.LA(3);

                if ( ((LA18_39 >= '0' && LA18_39 <= '9')||(LA18_39 >= 'A' && LA18_39 <= 'Z')||(LA18_39 >= 'a' && LA18_39 <= 'z')) ) {
                    alt18=7;
                }
                else {
                    alt18=4;
                }
            }
            else {
                alt18=7;
            }
            }
            break;
        case 'E':
            {
            int LA18_13 = input.LA(2);

            if ( ((LA18_13 >= '0' && LA18_13 <= '9')||(LA18_13 >= 'A' && LA18_13 <= 'Z')||(LA18_13 >= 'a' && LA18_13 <= 'z')) ) {
                alt18=7;
            }
            else {
                alt18=4;
            }
            }
            break;
        case '\t':
        case '\n':
        case '\r':
        case ' ':
            {
            alt18=5;
            }
            break;
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            {
            alt18=6;
            }
            break;
        case 'A':
        case 'B':
        case 'C':
        case 'G':
        case 'H':
        case 'J':
        case 'K':
        case 'M':
        case 'P':
        case 'Q':
        case 'R':
        case 'S':
        case 'U':
        case 'X':
        case 'Y':
        case 'Z':
        case 'a':
        case 'b':
        case 'c':
        case 'd':
        case 'e':
        case 'f':
        case 'g':
        case 'h':
        case 'j':
        case 'k':
        case 'l':
        case 'm':
        case 'n':
        case 'o':
        case 'p':
        case 'q':
        case 'r':
        case 's':
        case 't':
        case 'u':
        case 'x':
        case 'y':
        case 'z':
            {
            alt18=7;
            }
            break;
        case '*':
        case '+':
        case '-':
            {
            alt18=8;
            }
            break;
        case '/':
            {
            switch ( input.LA(2) ) {
            case '*':
                {
                alt18=17;
                }
                break;
            case '/':
                {
                alt18=18;
                }
                break;
            default:
                alt18=8;
            }

            }
            break;
        case '(':
        case ')':
            {
            alt18=9;
            }
            break;
        case '{':
        case '}':
            {
            alt18=10;
            }
            break;
        case ',':
            {
            alt18=11;
            }
            break;
        case '&':
            {
            alt18=12;
            }
            break;
        case '<':
        case '>':
            {
            alt18=13;
            }
            break;
        case ';':
            {
            alt18=14;
            }
            break;
        case '=':
            {
            alt18=15;
            }
            break;
        case '\"':
            {
            alt18=16;
            }
            break;
        default:
            if (state.backtracking>0) {state.failed=true; return ;}
            NoViableAltException nvae =
                new NoViableAltException("", 18, 0, input);

            throw nvae;

        }

        switch (alt18) {
            case 1 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:10: INT
                {
                mINT(); if (state.failed) return ;


                }
                break;
            case 2 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:14: VOID
                {
                mVOID(); if (state.failed) return ;


                }
                break;
            case 3 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:19: IF
                {
                mIF(); if (state.failed) return ;


                }
                break;
            case 4 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:22: WHILE
                {
                mWHILE(); if (state.failed) return ;


                }
                break;
            case 5 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:28: BLANCO
                {
                mBLANCO(); if (state.failed) return ;


                }
                break;
            case 6 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:35: NUMERO
                {
                mNUMERO(); if (state.failed) return ;


                }
                break;
            case 7 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:42: IDENT
                {
                mIDENT(); if (state.failed) return ;


                }
                break;
            case 8 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:48: OPERADOR
                {
                mOPERADOR(); if (state.failed) return ;


                }
                break;
            case 9 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:57: PARENTESIS
                {
                mPARENTESIS(); if (state.failed) return ;


                }
                break;
            case 10 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:68: LLAVES
                {
                mLLAVES(); if (state.failed) return ;


                }
                break;
            case 11 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:75: COMA
                {
                mCOMA(); if (state.failed) return ;


                }
                break;
            case 12 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:80: AMPERSAND
                {
                mAMPERSAND(); if (state.failed) return ;


                }
                break;
            case 13 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:90: COMPARADOR
                {
                mCOMPARADOR(); if (state.failed) return ;


                }
                break;
            case 14 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:101: SEPARADOR
                {
                mSEPARADOR(); if (state.failed) return ;


                }
                break;
            case 15 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:111: IGUAL
                {
                mIGUAL(); if (state.failed) return ;


                }
                break;
            case 16 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:117: CADENA
                {
                mCADENA(); if (state.failed) return ;


                }
                break;
            case 17 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:124: COMENTARIO
                {
                mCOMENTARIO(); if (state.failed) return ;


                }
                break;
            case 18 :
                // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:1:135: LINEA_COMENTARIO
                {
                mLINEA_COMENTARIO(); if (state.failed) return ;


                }
                break;

        }

    }

    // $ANTLR start synpred1_Analex
    public final void synpred1_Analex_fragment() throws RecognitionException {
        // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:65:10: ( ( DIGITO )+ '.' )
        // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:65:11: ( DIGITO )+ '.'
        {
        // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:65:11: ( DIGITO )+
        int cnt19=0;
        loop19:
        do {
            int alt19=2;
            int LA19_0 = input.LA(1);

            if ( ((LA19_0 >= '0' && LA19_0 <= '9')) ) {
                alt19=1;
            }


            switch (alt19) {
        	case 1 :
        	    // C:\\Users\\GMIRIAM\\workspace\\prac4\\src\\main\\java\\PL\\prac4\\Analex.g:
        	    {
        	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
        	        input.consume();
        	        state.failed=false;
        	    }
        	    else {
        	        if (state.backtracking>0) {state.failed=true; return ;}
        	        MismatchedSetException mse = new MismatchedSetException(null,input);
        	        recover(mse);
        	        throw mse;
        	    }


        	    }
        	    break;

        	default :
        	    if ( cnt19 >= 1 ) break loop19;
        	    if (state.backtracking>0) {state.failed=true; return ;}
                    EarlyExitException eee =
                        new EarlyExitException(19, input);
                    throw eee;
            }
            cnt19++;
        } while (true);


        match('.'); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred1_Analex

    public final boolean synpred1_Analex() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred1_Analex_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }


    protected DFA10 dfa10 = new DFA10(this);
    static final String DFA10_eotS =
        "\1\uffff\1\3\2\uffff";
    static final String DFA10_eofS =
        "\4\uffff";
    static final String DFA10_minS =
        "\1\60\1\56\2\uffff";
    static final String DFA10_maxS =
        "\2\71\2\uffff";
    static final String DFA10_acceptS =
        "\2\uffff\1\1\1\2";
    static final String DFA10_specialS =
        "\1\uffff\1\0\2\uffff}>";
    static final String[] DFA10_transitionS = {
            "\12\1",
            "\1\2\1\uffff\12\1",
            "",
            ""
    };

    static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
    static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
    static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS);
    static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS);
    static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
    static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS);
    static final short[][] DFA10_transition;

    static {
        int numStates = DFA10_transitionS.length;
        DFA10_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]);
        }
    }

    class DFA10 extends DFA {

        public DFA10(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 10;
            this.eot = DFA10_eot;
            this.eof = DFA10_eof;
            this.min = DFA10_min;
            this.max = DFA10_max;
            this.accept = DFA10_accept;
            this.special = DFA10_special;
            this.transition = DFA10_transition;
        }
        public String getDescription() {
            return "65:1: NUMERO : ( ( ( DIGITO )+ '.' )=> ( DIGITO )+ '.' ( DIGITO )* | ( DIGITO )+ );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            IntStream input = _input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA10_1 = input.LA(1);

                         
                        int index10_1 = input.index();
                        input.rewind();

                        s = -1;
                        if ( (LA10_1=='.') && (synpred1_Analex())) {s = 2;}

                        else if ( ((LA10_1 >= '0' && LA10_1 <= '9')) ) {s = 1;}

                        else s = 3;

                         
                        input.seek(index10_1);

                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}

            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 10, _s, input);
            error(nvae);
            throw nvae;
        }

    }
 

}